home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1998 / MacHack 1998.toast / Papers / C++ Exceptions / µShell / Core Utilities / MemUtils.cp < prev    next >
Encoding:
Text File  |  1998-06-02  |  3.7 KB  |  218 lines  |  [TEXT/CWIE]
  1. #ifndef __MEMUTILS__
  2. #include "MemUtils.h"
  3. #endif
  4. #ifndef __EXCEPTIONS__
  5. #include "Exceptions.h"
  6. #endif
  7.  
  8.  
  9. //------------------------------------------------------------------------------
  10. // Common constructor code
  11. //------------------------------------------------------------------------------
  12.  
  13. #pragma segment Main
  14.  
  15. void CAutoHandle::_CAutoHandle(Handle h, HandleState desiredState)
  16. {
  17.     fHandle = nil;    // in case of failure
  18.  
  19.     if (h != nil)
  20.     {
  21.         SignedByte state = HGetState(h);
  22.         FailMemError();
  23.         
  24.         fHandle = h;
  25.         fState  = (HandleState) (((short) desiredState) & 0xff00 | ((short) state) & 0x00FF);
  26.         
  27.         if (!(state & kHLocked))            
  28.         {    // It's not already locked
  29.  
  30.             if (!(kHPurge & desiredState & ~state))
  31.             {    // It's purgeable and we need to make it non-purgeable
  32.                 
  33.                 if ((state & kHResource) && (*h == nil))
  34.                 { // it's a purged resource
  35.                 
  36.                     LoadResource(h);
  37.                     FailResError();
  38.                 }
  39.  
  40.                 HNoPurge(h);
  41.                 FailMemError();
  42.             }
  43.         
  44.             if (desiredState & kHMoveHi)
  45.             {
  46.                 MoveHHi(h);
  47.             }
  48.  
  49.             if (desiredState & kHLocked)
  50.             {
  51.                 HLock(h);
  52.             }
  53.  
  54.             FailMemError();
  55.         }
  56.     }
  57.     else
  58.     {
  59.         fState = desiredState;
  60.     }
  61. }
  62.  
  63.  
  64. //------------------------------------------------------------------------------
  65. #pragma segment Main
  66.  
  67. CAutoHandle::CAutoHandle(
  68.     Size        size,
  69.     HandleState    desiredState)
  70. :    fHandle(nil)
  71. {
  72.     Handle h;
  73.     
  74.     if (desiredState & kHSysHeap)
  75.     {
  76.         h = (desiredState & kHClear) ? NewHandleSysClear(size) : NewHandleSys(size);
  77.     }
  78.     else if (desiredState & kHTempMem)
  79.     {
  80. //        h = (desiredState & kHClear) ? NewTempHandleClear(size) : NewHandleTemp(size);
  81.  
  82.         OSErr    err;
  83.         
  84.         h = TempNewHandle(size, &err);
  85.         FailNIL(h);
  86.         FailOSErr(err);
  87.         
  88.         if (desiredState & kHClear && size > 0)
  89.         {
  90.             BlockZero(*h, size);
  91.         }
  92.         
  93.     //    WarnIf((desiredState & kHClear), "temp handles not cleared");    //    REVIEW RMS
  94.     }
  95.     else
  96.     {
  97.         h = (desiredState & kHClear) ? NewHandleClear(size) : NewHandle(size);
  98.     }
  99.     
  100.     FailMemError();
  101.     
  102.     _CAutoHandle(h, desiredState);
  103. }
  104.  
  105.  
  106. //------------------------------------------------------------------------------
  107. #pragma segment Main
  108.  
  109. CAutoHandle::CAutoHandle(
  110.     const void*    data,
  111.     Size        size,
  112.     HandleState    desiredState)
  113. :    fHandle(nil)
  114. {
  115.     Handle h;
  116.     
  117.     if (desiredState & kHSysHeap)
  118.     {
  119.         h =  NewHandleSys(size);
  120.     }
  121.     else if (desiredState & kHTempMem)
  122.     {
  123.         OSErr    err;
  124.         
  125.         h = TempNewHandle(size, &err);    //    RMS 980216
  126.         FailNIL(h);
  127.         FailOSErr(err);
  128.     }
  129.     else
  130.     {
  131.         h = NewHandle(size);
  132.     }
  133.     
  134.     FailMemError();
  135.     
  136.     if (size > 0)
  137.     {
  138.         BlockMoveData(data, *h, size);
  139.     }
  140.     
  141.     _CAutoHandle(h, desiredState);
  142. }
  143.  
  144. //------------------------------------------------------------------------------
  145. #pragma segment Main
  146.  
  147. CAutoHandle::~CAutoHandle()
  148. {
  149.     Handle h = fHandle;    // for speed
  150.  
  151.     if (h != nil)
  152.     {
  153.         HandleState state = fState;    // for speed
  154.     
  155.         if (state & kHDispose)
  156.         {
  157.             if (state & kHResource)
  158.             {
  159.                 ReleaseResource(fHandle);
  160.                 LogIfErr(ResError());
  161.             }
  162.             else
  163.             {
  164.                 DisposeHandle(fHandle);
  165.                 LogIfErr(MemError());
  166.             }
  167.         }
  168.         else
  169.         {
  170.             HSetState(fHandle, (char) state);
  171.         }
  172.     }
  173. }
  174.  
  175. //------------------------------------------------------------------------------
  176. #pragma segment Main
  177.  
  178. CTempHandle::~CTempHandle()
  179. {
  180. }
  181.  
  182. //------------------------------------------------------------------------------
  183. #pragma segment Main
  184.  
  185. void CopyHandle(Handle src, Handle dst)
  186. {
  187.     Size    size = GetHandleSize(src);
  188.     OSErr     err = MemError();
  189.     
  190.     if (err == noErr)
  191.     { 
  192.         ::SetHandleSize(dst, size);
  193.         err = MemError();
  194.     }
  195.  
  196.     if (err == noErr)
  197.     { 
  198.         BlockMoveData(*src, *dst, size);
  199.     }
  200.     else
  201.     {
  202.         Throw(err);
  203.     }
  204. }
  205.  
  206. //------------------------------------------------------------------------------
  207. #pragma segment Main
  208.  
  209. void BlockZero(void* ptr, Size size)
  210. {
  211.     memset(ptr, 0, size);
  212. }
  213.  
  214. //------------------------------------------------------------------------------
  215.  
  216.  
  217.  
  218.